<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <script>
      function isSpecial(s) {
        const set = new Set(s.split(''));
        return set.size === 1;
      }
      //   function maximumLength(s) {
      //     let i = 0;
      //     let j = s.length - 2;
      //     let strArr = [];
      //     while (i < j && j <= s.length) {
      //       let str = '';
      //       for (let o = i; o < j; o++) {
      //         str += s[o];
      //       }
      //       if (isSpecial(str)) {
      //         i++;
      //         j++;
      //         strArr.push(str);
      //       } else {
      //         j--;

      //         console.log(str, '11');
      //         strArr = [];
      //       }
      //       console.log(str);
      //     }
      //     strArr.sort();
      //     console.log(strArr);
      //     for (let i = 2; i < strArr.length; i++) {
      //       if (strArr[i] === strArr[i - 2]) {
      //         return strArr[i].length;
      //       }
      //     }
      //     return -1;
      //   }

      //   function maximumLength(s) {
      //     const obj = {};
      //     for (let i = 0; i < s.length - 1; i++) {
      //       if (s[i] === s[i + 1]) {
      //         if (obj[s[i]] === undefined) {
      //           obj[s[i]] = 0;
      //         }
      //         obj[s[i]]++;
      //       }
      //     }
      //     const values = Object.values(obj);
      //     console.log(obj);
      //     if (values.filter((o) => o >= 3).length) {
      //       const max = Math.max(...values);
      //       return max >= 3 ? max - 1 : max;
      //     } else {
      //       const strArr = s.split('').sort();
      //       for (let i = 2; i < strArr.length; i++) {
      //         if (strArr[i] === strArr[i - 2]) {
      //           return 1;
      //         }
      //       }
      //     }
      //     return -1;
      //   }

      //   function maximumLength(s) {
      //     const obj = {};
      //     let str = '';
      //     for (let i = 0; i < s.length; i++) {
      //       str += s[i];
      //       if (isSpecial(str)) {
      //         if (!obj[s[i]]) {
      //           obj[s[i]] = '';
      //         }
      //         if (obj[s[i]].length < str.length) {
      //           obj[s[i]] = str;
      //         }
      //       } else {
      //         str = s[i];
      //       }
      //     }
      //     const arr = Object.values(obj)
      //       .map((item) => item.length - 1)
      //       .filter((o) => o >= 3);
      //     console.log(obj);
      //     if (!arr.length) {
      //       const strArr = s.split('').sort();
      //       for (let i = 2; i < strArr.length; i++) {
      //         if (strArr[i] === strArr[i - 2]) {
      //           return 1;
      //         }
      //       }
      //     } else {
      //       return Math.max(...arr) - 1;
      //     }
      //     return -1;
      //   }

      function maximumLength(s) {
        const obj = {};
        let count = 0;
        for (let i = 0; i < s.length; i++) {
          count++;
          // i + 1 === s.length 为了防止没有不同的字符串 比如 aaaa
          if (i + 1 === s.length || s[i] !== s[i + 1]) {
            if (!obj[s[i]]) {
              obj[s[i]] = [];
            }
            obj[s[i]].push(count);
            count = 0;
          }
        }
        let result = -1;
        for (const key in obj) {
          /**
           * 1. 如果数组中存在两个元素,并且a[0] === a[1] + 1 那么结果就是 a[1] ==> nnnnnlnnnn
           * 2. 如果数组中存在一个元素,并且a[0] > 3 那么结果就是 a[0] - 1 ==> nnnn
           * 3. 如果数组中存在三个或以上元素个数,并且a[1,2,3]都相同,那么结果就是 a[0] ==> nnn
           * 4. 前提条件,数组中的总和数必须 >= 3
           * **/
          const element = obj[key];
          const sum = element.reduce((pre, next) => pre + next, 0);
          if (sum < 3) continue;
          element.sort((a, b) => b - a);
          element.push(0);
          element.push(0);

          // 我原本的写法
          // if (element[0] >= 3) {
          //   result = Math.max(result, element[0] - 2);
          // }
          // if (element[0] === element[1] && element[1] === element[2]) {
          //   result = Math.max(result, element[0]);
          // }
          // if (element[0] === element[1] + 1) {
          //   result = Math.max(result, element[1]);
          // }
          // if (element[0] === element[1]) {
          //   result = Math.max(result, element[0] - 1);
          // }

          // 大佬的写法
          result = Math.max(
            result,
            element[0] - 2,
            Math.min(element[0] - 1, element[1]),
            element[2]
          );
        }
        return result;
      }

      /**
       * 思路 =>
       * 1. 先将相同的字符串分配到一个对象中,比如 nnn => {n:[3]} nnnnlnnn => {n:[4,3]}
       * 2. 如果数组中的和小于3直接跳过
       * 3. 如果数组中第一个 = 第二个+1 返回 第二个值
       * 4. 如果数组中只有一个元素,并且大于等于3 返回 第一个值 - 2
       * 5. 如果数组中有三个或以上元素,并且第一个,第二个,第三个元素相等,返回第一个值
       * 6. 如果数组中第一个值和第二个值相等,那么返回 第一个值 - 1
       *      其实 第 3 步 可以修改一下,比如 第一个值-1 = 第二个值,就返回第一个值
       *      这样就可以合并 第 3 步 和 第 6 步
       * **/

      // abcccccdddd  ==> 3
      // abcaba ==> 1
      // aaaa ==> 2
      // abcdef ==> -1
      // acc ==> -1
      // azzyyyyyyy ==> 5
      // eeeeddddee ==> 2
      // lkwwdddddnnnnnynnnnl ==> 4
      // aaa ==> 1
      // ceeeeeeeeeeeebmmmfffeeeeeeeeeeeewww ==> 11
      console.log(maximumLength('ceeeeeeeeeeeebmmmfffeeeeeeeeeeeewww'));
    </script>
  </body>
</html>
